Termination of the given ITRSProblem could not be shown:



↳ ITRS
  ↳ ITRStoIDPProof

ITRS problem:
The following domains are used:

z

The TRS R consists of the following rules:

st(n, l) → stNat(>=@z(n, 0@z), n, l)
sort(l) → st(0@z, l)
if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
cond1(TRUE, n, l) → cons(n, st(+@z(n, 1@z), l))
cond2(FALSE, n, l) → st(+@z(n, 1@z), l)
cond1(FALSE, n, l) → cond2(>@z(n, max(l)), n, l)
cond2(TRUE, n, l) → nil
if(TRUE, u, v) → u
member(n, nil) → FALSE
stNat(TRUE, n, l) → cond1(member(n, l), n, l)
max(nil) → 0@z

The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


Added dependency pairs

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

st(n, l) → stNat(>=@z(n, 0@z), n, l)
sort(l) → st(0@z, l)
if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
cond1(TRUE, n, l) → cons(n, st(+@z(n, 1@z), l))
cond2(FALSE, n, l) → st(+@z(n, 1@z), l)
cond1(FALSE, n, l) → cond2(>@z(n, max(l)), n, l)
cond2(TRUE, n, l) → nil
if(TRUE, u, v) → u
member(n, nil) → FALSE
stNat(TRUE, n, l) → cond1(member(n, l), n, l)
max(nil) → 0@z

The integer pair graph contains the following rules and edges:

(0): COND1(FALSE, n[0], l[0]) → MAX(l[0])
(1): COND1(FALSE, n[1], l[1]) → COND2(>@z(n[1], max(l[1])), n[1], l[1])
(2): MAX(cons(u[2], l[2])) → IF(>@z(u[2], max(l[2])), u[2], max(l[2]))
(3): MAX(cons(u[3], l[3])) → MAX(l[3])
(4): STNAT(TRUE, n[4], l[4]) → MEMBER(n[4], l[4])
(5): SORT(l[5]) → ST(0@z, l[5])
(6): STNAT(TRUE, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
(7): COND2(FALSE, n[7], l[7]) → ST(+@z(n[7], 1@z), l[7])
(8): MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])
(9): COND1(TRUE, n[9], l[9]) → ST(+@z(n[9], 1@z), l[9])
(10): ST(n[10], l[10]) → STNAT(>=@z(n[10], 0@z), n[10], l[10])

(0) -> (2), if ((l[0] →* cons(u[2], l[2])))


(0) -> (3), if ((l[0] →* cons(u[3], l[3])))


(1) -> (7), if ((n[1] →* n[7])∧(l[1] →* l[7])∧(>@z(n[1], max(l[1])) →* FALSE))


(3) -> (2), if ((l[3] →* cons(u[2], l[2])))


(3) -> (3), if ((l[3] →* cons(u[3]a, l[3]a)))


(4) -> (8), if ((l[4] →* cons(m[8], l[8]))∧(n[4] →* n[8]))


(5) -> (10), if ((l[5] →* l[10]))


(6) -> (0), if ((n[6] →* n[0])∧(l[6] →* l[0])∧(member(n[6], l[6]) →* FALSE))


(6) -> (1), if ((n[6] →* n[1])∧(l[6] →* l[1])∧(member(n[6], l[6]) →* FALSE))


(6) -> (9), if ((n[6] →* n[9])∧(l[6] →* l[9])∧(member(n[6], l[6]) →* TRUE))


(7) -> (10), if ((l[7] →* l[10])∧(+@z(n[7], 1@z) →* n[10]))


(8) -> (8), if ((l[8] →* cons(m[8]a, l[8]a))∧(n[8] →* n[8]a))


(9) -> (10), if ((l[9] →* l[10])∧(+@z(n[9], 1@z) →* n[10]))


(10) -> (4), if ((n[10] →* n[4])∧(l[10] →* l[4])∧(>=@z(n[10], 0@z) →* TRUE))


(10) -> (6), if ((n[10] →* n[6])∧(l[10] →* l[6])∧(>=@z(n[10], 0@z) →* TRUE))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
if(TRUE, u, v) → u
member(n, nil) → FALSE
max(nil) → 0@z

The integer pair graph contains the following rules and edges:

(0): COND1(FALSE, n[0], l[0]) → MAX(l[0])
(1): COND1(FALSE, n[1], l[1]) → COND2(>@z(n[1], max(l[1])), n[1], l[1])
(2): MAX(cons(u[2], l[2])) → IF(>@z(u[2], max(l[2])), u[2], max(l[2]))
(3): MAX(cons(u[3], l[3])) → MAX(l[3])
(4): STNAT(TRUE, n[4], l[4]) → MEMBER(n[4], l[4])
(5): SORT(l[5]) → ST(0@z, l[5])
(6): STNAT(TRUE, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
(7): COND2(FALSE, n[7], l[7]) → ST(+@z(n[7], 1@z), l[7])
(8): MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])
(9): COND1(TRUE, n[9], l[9]) → ST(+@z(n[9], 1@z), l[9])
(10): ST(n[10], l[10]) → STNAT(>=@z(n[10], 0@z), n[10], l[10])

(0) -> (2), if ((l[0] →* cons(u[2], l[2])))


(0) -> (3), if ((l[0] →* cons(u[3], l[3])))


(1) -> (7), if ((n[1] →* n[7])∧(l[1] →* l[7])∧(>@z(n[1], max(l[1])) →* FALSE))


(3) -> (2), if ((l[3] →* cons(u[2], l[2])))


(3) -> (3), if ((l[3] →* cons(u[3]a, l[3]a)))


(4) -> (8), if ((l[4] →* cons(m[8], l[8]))∧(n[4] →* n[8]))


(5) -> (10), if ((l[5] →* l[10]))


(6) -> (0), if ((n[6] →* n[0])∧(l[6] →* l[0])∧(member(n[6], l[6]) →* FALSE))


(6) -> (1), if ((n[6] →* n[1])∧(l[6] →* l[1])∧(member(n[6], l[6]) →* FALSE))


(6) -> (9), if ((n[6] →* n[9])∧(l[6] →* l[9])∧(member(n[6], l[6]) →* TRUE))


(7) -> (10), if ((l[7] →* l[10])∧(+@z(n[7], 1@z) →* n[10]))


(8) -> (8), if ((l[8] →* cons(m[8]a, l[8]a))∧(n[8] →* n[8]a))


(9) -> (10), if ((l[9] →* l[10])∧(+@z(n[9], 1@z) →* n[10]))


(10) -> (4), if ((n[10] →* n[4])∧(l[10] →* l[4])∧(>=@z(n[10], 0@z) →* TRUE))


(10) -> (6), if ((n[10] →* n[6])∧(l[10] →* l[6])∧(>=@z(n[10], 0@z) →* TRUE))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 3 SCCs with 4 less nodes.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
                ↳ UsableRulesProof
              ↳ IDP
              ↳ IDP

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
if(TRUE, u, v) → u
member(n, nil) → FALSE
max(nil) → 0@z

The integer pair graph contains the following rules and edges:

(3): MAX(cons(u[3], l[3])) → MAX(l[3])

(3) -> (3), if ((l[3] →* cons(u[3]a, l[3]a)))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
                ↳ UsableRulesProof
                  ↳ IDP
                    ↳ IDPNonInfProof
              ↳ IDP
              ↳ IDP

I DP problem:
The following domains are used:none

R is empty.
The integer pair graph contains the following rules and edges:

(3): MAX(cons(u[3], l[3])) → MAX(l[3])

(3) -> (3), if ((l[3] →* cons(u[3]a, l[3]a)))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair MAX(cons(u[3], l[3])) → MAX(l[3]) the following chains were created:




To summarize, we get the following constraints P≥ for the following pairs.



The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers with natural coefficients for non-tuple symbols [NONINF][POLO]:

POL(cons(x1, x2)) = -1 + x2   
POL(TRUE) = 0   
POL(FALSE) = 0   
POL(MAX(x1)) = -1 + (-1)x1   
POL(undefined) = 0   

The following pairs are in P>:

MAX(cons(u[3], l[3])) → MAX(l[3])

The following pairs are in Pbound:

MAX(cons(u[3], l[3])) → MAX(l[3])

The following pairs are in P≥:
none

There are no usable rules.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
                ↳ UsableRulesProof
                  ↳ IDP
                    ↳ IDPNonInfProof
                      ↳ IDP
                        ↳ IDependencyGraphProof
              ↳ IDP
              ↳ IDP

I DP problem:
The following domains are used:none

R is empty.
The integer pair graph is empty.
The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
                ↳ UsableRulesProof
              ↳ IDP

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
if(TRUE, u, v) → u
member(n, nil) → FALSE
max(nil) → 0@z

The integer pair graph contains the following rules and edges:

(8): MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])

(8) -> (8), if ((l[8] →* cons(m[8]a, l[8]a))∧(n[8] →* n[8]a))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
                ↳ UsableRulesProof
                  ↳ IDP
                    ↳ IDPNonInfProof
              ↳ IDP

I DP problem:
The following domains are used:none

R is empty.
The integer pair graph contains the following rules and edges:

(8): MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])

(8) -> (8), if ((l[8] →* cons(m[8]a, l[8]a))∧(n[8] →* n[8]a))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8]) the following chains were created:




To summarize, we get the following constraints P≥ for the following pairs.



The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers with natural coefficients for non-tuple symbols [NONINF][POLO]:

POL(cons(x1, x2)) = 2 + x2   
POL(MEMBER(x1, x2)) = -1 + x2 + (-1)x1   
POL(TRUE) = 0   
POL(FALSE) = 0   
POL(undefined) = 0   

The following pairs are in P>:

MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])

The following pairs are in Pbound:

MEMBER(n[8], cons(m[8], l[8])) → MEMBER(n[8], l[8])

The following pairs are in P≥:
none

There are no usable rules.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
                ↳ UsableRulesProof
                  ↳ IDP
                    ↳ IDPNonInfProof
                      ↳ IDP
                        ↳ IDependencyGraphProof
              ↳ IDP

I DP problem:
The following domains are used:none

R is empty.
The integer pair graph is empty.
The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

if(FALSE, u, v) → v
member(n, cons(m, l)) → ||(=@z(n, m), member(n, l))
max(cons(u, l)) → if(>@z(u, max(l)), u, max(l))
if(TRUE, u, v) → u
member(n, nil) → FALSE
max(nil) → 0@z

The integer pair graph contains the following rules and edges:

(7): COND2(FALSE, n[7], l[7]) → ST(+@z(n[7], 1@z), l[7])
(1): COND1(FALSE, n[1], l[1]) → COND2(>@z(n[1], max(l[1])), n[1], l[1])
(10): ST(n[10], l[10]) → STNAT(>=@z(n[10], 0@z), n[10], l[10])
(9): COND1(TRUE, n[9], l[9]) → ST(+@z(n[9], 1@z), l[9])
(6): STNAT(TRUE, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])

(6) -> (9), if ((n[6] →* n[9])∧(l[6] →* l[9])∧(member(n[6], l[6]) →* TRUE))


(10) -> (6), if ((n[10] →* n[6])∧(l[10] →* l[6])∧(>=@z(n[10], 0@z) →* TRUE))


(6) -> (1), if ((n[6] →* n[1])∧(l[6] →* l[1])∧(member(n[6], l[6]) →* FALSE))


(1) -> (7), if ((n[1] →* n[7])∧(l[1] →* l[7])∧(>@z(n[1], max(l[1])) →* FALSE))


(7) -> (10), if ((l[7] →* l[10])∧(+@z(n[7], 1@z) →* n[10]))


(9) -> (10), if ((l[9] →* l[10])∧(+@z(n[9], 1@z) →* n[10]))



The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(FALSE, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(TRUE, x0, x1)
cond2(FALSE, x0, x1)
cond1(FALSE, x0, x1)
cond2(TRUE, x0, x1)
if(TRUE, x0, x1)
member(x0, nil)
stNat(TRUE, x0, x1)
max(nil)


Represented integers and predefined function symbols by Terms

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
ST(n[10], l[10]) → STNAT(greatereq_int(n[10], pos(0)), n[10], l[10])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])

The TRS R consists of the following rules:

if(false, u, v) → v
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
if(true, u, v) → u
member(n, nil) → false
max(nil) → pos(0)
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(neg(x), pos(y)) → minus_nat(y, x)
plus_int(neg(x), neg(y)) → neg(plus_nat(x, y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(0), neg(y)) → true
greatereq_int(pos(x), neg(y)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(neg(x), pos(s(y))) → false
greatereq_int(neg(s(x)), pos(0)) → false
greatereq_int(neg(s(x)), neg(0)) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
greatereq_int(neg(s(x)), neg(s(y))) → greatereq_int(neg(x), neg(y))

The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(true, x0, x1)
cond2(false, x0, x1)
cond1(false, x0, x1)
cond2(true, x0, x1)
if(true, x0, x1)
member(x0, nil)
stNat(true, x0, x1)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
ST(n[10], l[10]) → STNAT(greatereq_int(n[10], pos(0)), n[10], l[10])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])

The TRS R consists of the following rules:

greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(s(x)), pos(0)) → false
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true

The set Q consists of the following terms:

st(x0, x1)
sort(x0)
if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
cond1(true, x0, x1)
cond2(false, x0, x1)
cond1(false, x0, x1)
cond2(true, x0, x1)
if(true, x0, x1)
member(x0, nil)
stNat(true, x0, x1)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

st(x0, x1)
sort(x0)
cond1(true, x0, x1)
cond2(false, x0, x1)
cond1(false, x0, x1)
cond2(true, x0, x1)
stNat(true, x0, x1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
ST(n[10], l[10]) → STNAT(greatereq_int(n[10], pos(0)), n[10], l[10])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])

The TRS R consists of the following rules:

greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(s(x)), pos(0)) → false
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule ST(n[10], l[10]) → STNAT(greatereq_int(n[10], pos(0)), n[10], l[10]) at position [0] we obtained the following new rules [LPAR04]:

ST(neg(s(x0)), y1) → STNAT(false, neg(s(x0)), y1)
ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
ST(neg(0), y1) → STNAT(true, neg(0), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
ST(neg(s(x0)), y1) → STNAT(false, neg(s(x0)), y1)
ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
ST(neg(0), y1) → STNAT(true, neg(0), y1)

The TRS R consists of the following rules:

greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(s(x)), pos(0)) → false
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
ST(neg(0), y1) → STNAT(true, neg(0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])

The TRS R consists of the following rules:

greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(s(x)), pos(0)) → false
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
ST(neg(0), y1) → STNAT(true, neg(0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
ST(neg(0), y1) → STNAT(true, neg(0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ST(neg(0), y1) → STNAT(true, neg(0), y1)
The remaining pairs can at least be oriented weakly.

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 1   
POL(COND1(x1, x2, x3)) = 0   
POL(COND2(x1, x2, x3)) = 0   
POL(ST(x1, x2)) = x1   
POL(STNAT(x1, x2, x3)) = 0   
POL(cons(x1, x2)) = 0   
POL(equal_int(x1, x2)) = 0   
POL(false) = 0   
POL(greater_int(x1, x2)) = 0   
POL(if(x1, x2, x3)) = 0   
POL(max(x1)) = 0   
POL(member(x1, x2)) = 0   
POL(minus_nat(x1, x2)) = 0   
POL(neg(x1)) = x1   
POL(nil) = 0   
POL(or(x1, x2)) = 0   
POL(plus_int(x1, x2)) = 0   
POL(plus_nat(x1, x2)) = 0   
POL(pos(x1)) = 0   
POL(s(x1)) = 0   
POL(true) = 0   

The following usable rules [FROCOS05] were oriented:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6])
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(0)) is replaced by the fresh variable x_removed.
Pair: COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
Positions in right side of the pair: Pair: COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                  ↳ QDP
                                                ↳ RemovalProof
                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1, x_removed) → STNAT(true, pos(x0), y1, x_removed)
STNAT(true, n[6], l[6], x_removed) → COND1(member(n[6], l[6]), n[6], l[6], x_removed)
COND1(true, n[9], l[9], x_removed) → ST(plus_int(x_removed, n[9]), l[9], x_removed)
COND1(false, n[1], l[1], x_removed) → COND2(greater_int(n[1], max(l[1])), n[1], l[1], x_removed)
COND2(false, n[7], l[7], x_removed) → ST(plus_int(x_removed, n[7]), l[7], x_removed)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(0)) is replaced by the fresh variable x_removed.
Pair: COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
Positions in right side of the pair: Pair: COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                  ↳ QDP
                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1, x_removed) → STNAT(true, pos(x0), y1, x_removed)
STNAT(true, n[6], l[6], x_removed) → COND1(member(n[6], l[6]), n[6], l[6], x_removed)
COND1(true, n[9], l[9], x_removed) → ST(plus_int(x_removed, n[9]), l[9], x_removed)
COND1(false, n[1], l[1], x_removed) → COND2(greater_int(n[1], max(l[1])), n[1], l[1], x_removed)
COND2(false, n[7], l[7], x_removed) → ST(plus_int(x_removed, n[7]), l[7], x_removed)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule STNAT(true, n[6], l[6]) → COND1(member(n[6], l[6]), n[6], l[6]) at position [0] we obtained the following new rules [LPAR04]:

STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9])
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND1(true, n[9], l[9]) → ST(plus_int(pos(s(0)), n[9]), l[9]) at position [0] we obtained the following new rules [LPAR04]:

COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1) at position [0,0] we obtained the following new rules [LPAR04]:

COND1(true, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1) at position [0,0,0] we obtained the following new rules [LPAR04]:

COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1])
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND1(false, n[1], l[1]) → COND2(greater_int(n[1], max(l[1])), n[1], l[1]) at position [0] we obtained the following new rules [LPAR04]:

COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7])
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND2(false, n[7], l[7]) → ST(plus_int(pos(s(0)), n[7]), l[7]) at position [0] we obtained the following new rules [LPAR04]:

COND2(false, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)

The TRS R consists of the following rules:

member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)

The TRS R consists of the following rules:

minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1)
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)

The TRS R consists of the following rules:

minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(x1), y1) → ST(pos(plus_nat(s(0), x1)), y1) at position [0,0] we obtained the following new rules [LPAR04]:

COND2(false, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND2(false, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1)

The TRS R consists of the following rules:

minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ UsableRulesProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND2(false, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1)

The TRS R consists of the following rules:

equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
plus_nat(0, x) → x

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(x1), y1) → ST(pos(s(plus_nat(0, x1))), y1) at position [0,0,0] we obtained the following new rules [LPAR04]:

COND2(false, pos(x1), y1) → ST(pos(s(x1)), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ AND
              ↳ IDP
              ↳ IDP
              ↳ IDP
                ↳ IDPtoQDPProof
                  ↳ QDP
                    ↳ UsableRulesProof
                      ↳ QDP
                        ↳ QReductionProof
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ QDPOrderProof
                                              ↳ QDP
                                                ↳ RemovalProof
                                                ↳ RemovalProof
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ UsableRulesProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ST(pos(x0), y1) → STNAT(true, pos(x0), y1)
STNAT(true, x0, nil) → COND1(false, x0, nil)
STNAT(true, x0, cons(x1, x2)) → COND1(or(equal_int(x0, x1), member(x0, x2)), x0, cons(x1, x2))
COND1(true, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND1(true, pos(x1), y1) → ST(pos(s(x1)), y1)
COND1(false, y0, nil) → COND2(greater_int(y0, pos(0)), y0, nil)
COND1(false, y0, cons(x0, x1)) → COND2(greater_int(y0, if(greater_int(x0, max(x1)), x0, max(x1))), y0, cons(x0, x1))
COND2(false, neg(x1), y1) → ST(minus_nat(s(0), x1), y1)
COND2(false, pos(x1), y1) → ST(pos(s(x1)), y1)

The TRS R consists of the following rules:

equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
member(n, cons(m, l)) → or(equal_int(n, m), member(n, l))
member(n, nil) → false
or(false, false) → false
or(false, true) → true
or(true, false) → true
or(true, true) → true
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
max(cons(u, l)) → if(greater_int(u, max(l)), u, max(l))
max(nil) → pos(0)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
if(false, u, v) → v
if(true, u, v) → u
plus_nat(0, x) → x

The set Q consists of the following terms:

if(false, x0, x1)
member(x0, cons(x1, x2))
max(cons(x0, x1))
if(true, x0, x1)
member(x0, nil)
max(nil)
or(false, false)
or(false, true)
or(true, false)
or(true, true)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.